'Weak Dependency Graph [60.0]'
------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))}
Details:
We have computed the following set of weak (innermost) dependency pairs:
{ q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, 0^#(q1(1(x1))) -> c_3(q2^#(0(1'(x1))))
, 0'^#(q1(1(x1))) -> c_4(q2^#(0'(1'(x1))))
, 1'^#(q1(1(x1))) -> c_5(q2^#(1'(1'(x1))))
, 0^#(q2(0(x1))) -> c_6(q2^#(0(0(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, 0^#(q2(1'(x1))) -> c_9(q2^#(0(1'(x1))))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q3^#(b(x1)) -> c_15()}
The usable rules are:
{ q0(0(x1)) -> 0'(q1(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
The estimated dependency graph contains the following edges:
{q0^#(0(x1)) -> c_0(0'^#(q1(x1)))}
==> {0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))}
{q0^#(0(x1)) -> c_0(0'^#(q1(x1)))}
==> {0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
{q0^#(0(x1)) -> c_0(0'^#(q1(x1)))}
==> {0'^#(q1(1(x1))) -> c_4(q2^#(0'(1'(x1))))}
{q1^#(0(x1)) -> c_1(0^#(q1(x1)))}
==> {0^#(q2(1'(x1))) -> c_9(q2^#(0(1'(x1))))}
{q1^#(0(x1)) -> c_1(0^#(q1(x1)))}
==> {0^#(q2(0(x1))) -> c_6(q2^#(0(0(x1))))}
{q1^#(0(x1)) -> c_1(0^#(q1(x1)))}
==> {0^#(q1(1(x1))) -> c_3(q2^#(0(1'(x1))))}
{q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
==> {1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
{q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
==> {1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
{q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
==> {1'^#(q1(1(x1))) -> c_5(q2^#(1'(1'(x1))))}
{0^#(q1(1(x1))) -> c_3(q2^#(0(1'(x1))))}
==> {q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
{0'^#(q1(1(x1))) -> c_4(q2^#(0'(1'(x1))))}
==> {q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
{1'^#(q1(1(x1))) -> c_5(q2^#(1'(1'(x1))))}
==> {q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
{0^#(q2(0(x1))) -> c_6(q2^#(0(0(x1))))}
==> {q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
{0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
==> {q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
{1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
==> {q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
{0^#(q2(1'(x1))) -> c_9(q2^#(0(1'(x1))))}
==> {q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
{0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))}
==> {q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
{1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
==> {q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
{q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
==> {0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))}
{q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
==> {0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
{q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))}
==> {1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
{q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))}
==> {1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
{q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))}
==> {1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
{q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))}
==> {1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
We consider the following path(s):
1) { q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, 0^#(q2(1'(x1))) -> c_9(q2^#(0(1'(x1))))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
The usable rules for this path are the following:
{ q0(0(x1)) -> 0'(q1(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(1'(x1))) -> c_9(q2^#(0(1'(x1))))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{q0(1'(x1)) -> 1'(q3(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(1'(x1)) -> 1'(q3(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [8]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [1]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q3(b(x1)) -> b(q4(x1))}
and weakly orienting the rules
{q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q3(b(x1)) -> b(q4(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
and weakly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [15]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [1]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [7]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [1]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q1^#(0(x1)) -> c_1(0^#(q1(x1)))}
and weakly orienting the rules
{ 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q1^#(0(x1)) -> c_1(0^#(q1(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [15]
q1^#(x1) = [1] x1 + [9]
c_1(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [3]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(1'(x1))) -> c_9(q2^#(0(1'(x1))))}
and weakly orienting the rules
{ q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(1'(x1))) -> c_9(q2^#(0(1'(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [9]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(0(x1)) -> 0'(q1(x1))}
and weakly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(1'(x1))) -> c_9(q2^#(0(1'(x1))))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(0(x1)) -> 0'(q1(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [11]
0(x1) = [1] x1 + [4]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [8]
1'(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [12]
q3(x1) = [1] x1 + [11]
b(x1) = [1] x1 + [2]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [5]
q1^#(x1) = [1] x1 + [13]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [9]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [15]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [1]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [1]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))}
and weakly orienting the rules
{ q0(0(x1)) -> 0'(q1(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(1'(x1))) -> c_9(q2^#(0(1'(x1))))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [9]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [7]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [8]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [11]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [1]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [3]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
and weakly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q0(0(x1)) -> 0'(q1(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(1'(x1))) -> c_9(q2^#(0(1'(x1))))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [2]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [2]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [8]
q2(x1) = [1] x1 + [8]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [8]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [14]
q1^#(x1) = [1] x1 + [8]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [7]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [15]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q0(0(x1)) -> 0'(q1(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(1'(x1))) -> c_9(q2^#(0(1'(x1))))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q0(0(x1)) -> 0'(q1(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(1'(x1))) -> c_9(q2^#(0(1'(x1))))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(6) -> 6
, 1_0(9) -> 6
, 1_0(10) -> 6
, b_0(6) -> 9
, b_0(9) -> 9
, b_0(10) -> 9
, q4_0(6) -> 10
, q4_0(9) -> 10
, q4_0(10) -> 10
, 0'^#_0(6) -> 13
, 0'^#_0(9) -> 13
, 0'^#_0(10) -> 13
, q1^#_0(6) -> 14
, q1^#_0(9) -> 14
, q1^#_0(10) -> 14
, 0^#_0(6) -> 16
, 0^#_0(9) -> 16
, 0^#_0(10) -> 16
, q2^#_0(6) -> 20
, q2^#_0(9) -> 20
, q2^#_0(10) -> 20}
2) { q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
The usable rules for this path are the following:
{ q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [7]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [1]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [1] x1 + [1]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q3(b(x1)) -> b(q4(x1))}
and weakly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q3(b(x1)) -> b(q4(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [15]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [15]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [1] x1 + [8]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))}
and weakly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [7]
q4(x1) = [1] x1 + [1]
q0^#(x1) = [1] x1 + [10]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [8]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [5]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [4]
c_13(x1) = [1] x1 + [7]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
and weakly orienting the rules
{ q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [4]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [7]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [4]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [1]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [1] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q2(0'(x1)) -> 0'(q0(x1))}
and weakly orienting the rules
{ 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q2(0'(x1)) -> 0'(q0(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [2]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [1]
c_8(x1) = [1] x1 + [1]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [1] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
and weakly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [8]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [8]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [1]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [2]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [1]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [3]
c_8(x1) = [1] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [3]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [1] x1 + [1]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))}
and weakly orienting the rules
{ q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [2]
1'(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [1]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [1] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(0(x1)) -> 0'(q1(x1))}
and weakly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(0(x1)) -> 0'(q1(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [12]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [8]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [8]
q2(x1) = [1] x1 + [14]
q3(x1) = [1] x1 + [12]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [12]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [13]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [1]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [1] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(6) -> 6
, 1_0(9) -> 6
, 1_0(10) -> 6
, b_0(6) -> 9
, b_0(9) -> 9
, b_0(10) -> 9
, q4_0(6) -> 10
, q4_0(9) -> 10
, q4_0(10) -> 10
, q0^#_0(6) -> 11
, q0^#_0(9) -> 11
, q0^#_0(10) -> 11
, 0'^#_0(6) -> 13
, 0'^#_0(9) -> 13
, 0'^#_0(10) -> 13
, 1'^#_0(6) -> 18
, 1'^#_0(9) -> 18
, 1'^#_0(10) -> 18
, q2^#_0(6) -> 20
, q2^#_0(9) -> 20
, q2^#_0(10) -> 20}
3) { q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, 0^#(q1(1(x1))) -> c_3(q2^#(0(1'(x1))))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
The usable rules for this path are the following:
{ q0(0(x1)) -> 0'(q1(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q1(1(x1))) -> c_3(q2^#(0(1'(x1))))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{q0(1'(x1)) -> 1'(q3(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(1'(x1)) -> 1'(q3(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [1]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q3(b(x1)) -> b(q4(x1))}
and weakly orienting the rules
{q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q3(b(x1)) -> b(q4(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [8]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [1]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
and weakly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [8]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [3]
q1^#(x1) = [1] x1 + [5]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [1]
q2^#(x1) = [1] x1 + [8]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0^#(q1(1(x1))) -> c_3(q2^#(0(1'(x1))))}
and weakly orienting the rules
{ q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0^#(q1(1(x1))) -> c_3(q2^#(0(1'(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))}
and weakly orienting the rules
{ 0^#(q1(1(x1))) -> c_3(q2^#(0(1'(x1))))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [8]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [8]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [1]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [8]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(0(x1)) -> 0'(q1(x1))}
and weakly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0^#(q1(1(x1))) -> c_3(q2^#(0(1'(x1))))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(0(x1)) -> 0'(q1(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
q2^#(x1) = [1] x1 + [1]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [7]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [1]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q2(0'(x1)) -> 0'(q0(x1))}
and weakly orienting the rules
{ q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0^#(q1(1(x1))) -> c_3(q2^#(0(1'(x1))))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q2(0'(x1)) -> 0'(q0(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [4]
1(x1) = [1] x1 + [7]
q2(x1) = [1] x1 + [4]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [9]
c_1(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [1]
q2^#(x1) = [1] x1 + [1]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [7]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [8]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
and weakly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0^#(q1(1(x1))) -> c_3(q2^#(0(1'(x1))))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [2]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [10]
1(x1) = [1] x1 + [13]
q2(x1) = [1] x1 + [2]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [1]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [2]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [1]
q2^#(x1) = [1] x1 + [2]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0^#(q1(1(x1))) -> c_3(q2^#(0(1'(x1))))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0^#(q1(1(x1))) -> c_3(q2^#(0(1'(x1))))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(6) -> 6
, 1_0(9) -> 6
, 1_0(10) -> 6
, b_0(6) -> 9
, b_0(9) -> 9
, b_0(10) -> 9
, q4_0(6) -> 10
, q4_0(9) -> 10
, q4_0(10) -> 10
, 0'^#_0(6) -> 13
, 0'^#_0(9) -> 13
, 0'^#_0(10) -> 13
, q1^#_0(6) -> 14
, q1^#_0(9) -> 14
, q1^#_0(10) -> 14
, 0^#_0(6) -> 16
, 0^#_0(9) -> 16
, 0^#_0(10) -> 16
, q2^#_0(6) -> 20
, q2^#_0(9) -> 20
, q2^#_0(10) -> 20}
4) { q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
The usable rules for this path are the following:
{ q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [7]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [1]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [1]
c_14(x1) = [1] x1 + [1]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q3(b(x1)) -> b(q4(x1))}
and weakly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q3(b(x1)) -> b(q4(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [15]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [15]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [1]
c_14(x1) = [1] x1 + [8]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))}
and weakly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [7]
q4(x1) = [1] x1 + [1]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [8]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [5]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [4]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [10]
c_14(x1) = [1] x1 + [7]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
and weakly orienting the rules
{ q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [4]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [7]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [4]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [1]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [9]
c_14(x1) = [1] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q2(0'(x1)) -> 0'(q0(x1))}
and weakly orienting the rules
{ 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q2(0'(x1)) -> 0'(q0(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [2]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [1]
c_8(x1) = [1] x1 + [1]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [1]
c_14(x1) = [1] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
and weakly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [8]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [8]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [1]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [2]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [1]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [3]
c_8(x1) = [1] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [3]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [9]
c_14(x1) = [1] x1 + [1]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))}
and weakly orienting the rules
{ q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [2]
1'(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [1]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [0]
c_14(x1) = [1] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(0(x1)) -> 0'(q1(x1))}
and weakly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(0(x1)) -> 0'(q1(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [12]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [8]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [8]
q2(x1) = [1] x1 + [14]
q3(x1) = [1] x1 + [12]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [13]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [1]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [12]
c_14(x1) = [1] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(2) -> 2
, b_0(2) -> 2
, q4_0(2) -> 2
, 0'^#_0(2) -> 1
, 1'^#_0(2) -> 1
, q2^#_0(2) -> 1
, q3^#_0(2) -> 1}
5) { q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, 1'^#(q1(1(x1))) -> c_5(q2^#(1'(1'(x1))))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
The usable rules for this path are the following:
{ q0(0(x1)) -> 0'(q1(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q1(1(x1))) -> c_5(q2^#(1'(1'(x1))))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{q0(1'(x1)) -> 1'(q3(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(1'(x1)) -> 1'(q3(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
1'^#(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q3(b(x1)) -> b(q4(x1))}
and weakly orienting the rules
{q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q3(b(x1)) -> b(q4(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [8]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
1'^#(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
and weakly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [8]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [9]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
1'^#(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [12]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [12]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [3]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{1'^#(q1(1(x1))) -> c_5(q2^#(1'(1'(x1))))}
and weakly orienting the rules
{ q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{1'^#(q1(1(x1))) -> c_5(q2^#(1'(1'(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
1'^#(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))}
and weakly orienting the rules
{ 1'^#(q1(1(x1))) -> c_5(q2^#(1'(1'(x1))))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [12]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [8]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [13]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
1'^#(x1) = [1] x1 + [13]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [2]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [15]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [8]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [8]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
and weakly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 1'^#(q1(1(x1))) -> c_5(q2^#(1'(1'(x1))))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q2(0'(x1)) -> 0'(q0(x1))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [15]
q2(x1) = [1] x1 + [12]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [8]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [15]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(0(x1)) -> 0'(q1(x1))}
and weakly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 1'^#(q1(1(x1))) -> c_5(q2^#(1'(1'(x1))))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(0(x1)) -> 0'(q1(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [8]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [8]
1(x1) = [1] x1 + [9]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [1]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [9]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [2]
1'^#(x1) = [1] x1 + [8]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [10]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))}
and weakly orienting the rules
{ q0(0(x1)) -> 0'(q1(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 1'^#(q1(1(x1))) -> c_5(q2^#(1'(1'(x1))))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [2]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [15]
q2(x1) = [1] x1 + [12]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [8]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [5]
q1^#(x1) = [1] x1 + [9]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [15]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q0(0(x1)) -> 0'(q1(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 1'^#(q1(1(x1))) -> c_5(q2^#(1'(1'(x1))))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q0(0(x1)) -> 0'(q1(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 1'^#(q1(1(x1))) -> c_5(q2^#(1'(1'(x1))))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(2) -> 2
, b_0(2) -> 2
, q4_0(2) -> 2
, 0'^#_0(2) -> 1
, q1^#_0(2) -> 1
, 1'^#_0(2) -> 1
, q2^#_0(2) -> 1}
6) { q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
The usable rules for this path are the following:
{ q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [7]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [1] x1 + [1]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [1] x1 + [1]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q3(b(x1)) -> b(q4(x1))}
and weakly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q3(b(x1)) -> b(q4(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [15]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [15]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [1] x1 + [8]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))}
and weakly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [7]
q4(x1) = [1] x1 + [1]
q0^#(x1) = [1] x1 + [10]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [8]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [1] x1 + [5]
c_12(x1) = [1] x1 + [4]
c_13(x1) = [1] x1 + [7]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
and weakly orienting the rules
{ q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [4]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [7]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [4]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [1] x1 + [1]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [1] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q2(0'(x1)) -> 0'(q0(x1))}
and weakly orienting the rules
{ 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q2(0'(x1)) -> 0'(q0(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [2]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [1]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [1] x1 + [1]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [1] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
and weakly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [8]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [8]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [1]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [2]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [1]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [3]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [3]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [1] x1 + [1]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))}
and weakly orienting the rules
{ q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [2]
1'(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [1]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [15]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [1] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(0(x1)) -> 0'(q1(x1))}
and weakly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(0(x1)) -> 0'(q1(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [12]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [8]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [8]
q2(x1) = [1] x1 + [14]
q3(x1) = [1] x1 + [12]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [12]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [13]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [1]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [1] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(2) -> 2
, b_0(2) -> 2
, q4_0(2) -> 2
, q0^#_0(2) -> 1
, 0'^#_0(2) -> 1
, 1'^#_0(2) -> 1
, q2^#_0(2) -> 1}
7) { q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
The usable rules for this path are the following:
{ q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [7]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [1] x1 + [1]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [1]
c_14(x1) = [1] x1 + [1]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q3(b(x1)) -> b(q4(x1))}
and weakly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q3(b(x1)) -> b(q4(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [15]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [15]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [1]
c_14(x1) = [1] x1 + [8]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))}
and weakly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [7]
q4(x1) = [1] x1 + [1]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [8]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [1] x1 + [5]
c_12(x1) = [1] x1 + [4]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [10]
c_14(x1) = [1] x1 + [7]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
and weakly orienting the rules
{ q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [4]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [7]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [4]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [1] x1 + [1]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [9]
c_14(x1) = [1] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q2(0'(x1)) -> 0'(q0(x1))}
and weakly orienting the rules
{ 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q2(0'(x1)) -> 0'(q0(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [2]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [1]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [1] x1 + [1]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [1]
c_14(x1) = [1] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
and weakly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [8]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [8]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [1]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [2]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [1]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [3]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [3]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [9]
c_14(x1) = [1] x1 + [1]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))}
and weakly orienting the rules
{ q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [2]
1'(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [1]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [15]
c_14(x1) = [1] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(0(x1)) -> 0'(q1(x1))}
and weakly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(0(x1)) -> 0'(q1(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [12]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [8]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [8]
q2(x1) = [1] x1 + [14]
q3(x1) = [1] x1 + [12]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [13]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [1]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [12]
c_14(x1) = [1] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(2) -> 2
, b_0(2) -> 2
, q4_0(2) -> 2
, 0'^#_0(2) -> 1
, 1'^#_0(2) -> 1
, q2^#_0(2) -> 1
, q3^#_0(2) -> 1}
8) { q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, 0^#(q2(0(x1))) -> c_6(q2^#(0(0(x1))))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
The usable rules for this path are the following:
{ q0(0(x1)) -> 0'(q1(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(0(x1))) -> c_6(q2^#(0(0(x1))))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [8]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [15]
q1^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q3(b(x1)) -> b(q4(x1))}
and weakly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q3(b(x1)) -> b(q4(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q1^#(0(x1)) -> c_1(0^#(q1(x1)))}
and weakly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q1^#(0(x1)) -> c_1(0^#(q1(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [15]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [9]
c_1(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(0(x1))) -> c_6(q2^#(0(0(x1))))}
and weakly orienting the rules
{ q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(0(x1))) -> c_6(q2^#(0(0(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [9]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [7]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [8]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [1] x1 + [7]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))}
and weakly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(0(x1))) -> c_6(q2^#(0(0(x1))))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [8]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [8]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [7]
q1^#(x1) = [1] x1 + [9]
c_1(x1) = [1] x1 + [3]
0^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [9]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
and weakly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(0(x1))) -> c_6(q2^#(0(0(x1))))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [9]
q2(x1) = [1] x1 + [8]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [1]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [8]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [6]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(0(x1)) -> 0'(q1(x1))}
and weakly orienting the rules
{ q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(0(x1))) -> c_6(q2^#(0(0(x1))))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(0(x1)) -> 0'(q1(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [8]
q2(x1) = [1] x1 + [4]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [3]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [5]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [5]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [1]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(0(x1))) -> c_6(q2^#(0(0(x1))))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(0(x1))) -> c_6(q2^#(0(0(x1))))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(6) -> 6
, 1_0(9) -> 6
, 1_0(10) -> 6
, b_0(6) -> 9
, b_0(9) -> 9
, b_0(10) -> 9
, q4_0(6) -> 10
, q4_0(9) -> 10
, q4_0(10) -> 10
, 0'^#_0(6) -> 13
, 0'^#_0(9) -> 13
, 0'^#_0(10) -> 13
, q1^#_0(6) -> 14
, q1^#_0(9) -> 14
, q1^#_0(10) -> 14
, 0^#_0(6) -> 16
, 0^#_0(9) -> 16
, 0^#_0(10) -> 16
, q2^#_0(6) -> 20
, q2^#_0(9) -> 20
, q2^#_0(10) -> 20}
9) { q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
The usable rules for this path are the following:
{ q0(0(x1)) -> 0'(q1(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{q3(b(x1)) -> b(q4(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q3(b(x1)) -> b(q4(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [2]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [1]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))}
and weakly orienting the rules
{q3(b(x1)) -> b(q4(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q0(1'(x1)) -> 1'(q3(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
and weakly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [9]
c_0(x1) = [1] x1 + [0]
0'^#(x1) = [1] x1 + [7]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))}
and weakly orienting the rules
{ 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [8]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
0'^#(x1) = [1] x1 + [1]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q2(0'(x1)) -> 0'(q0(x1))}
and weakly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q2(0'(x1)) -> 0'(q0(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [8]
q2(x1) = [1] x1 + [2]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [4]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [15]
c_0(x1) = [1] x1 + [0]
0'^#(x1) = [1] x1 + [15]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [7]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [9]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
and weakly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [12]
q2(x1) = [1] x1 + [8]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [9]
c_0(x1) = [1] x1 + [5]
0'^#(x1) = [1] x1 + [4]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [7]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [1]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [1]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(0(x1)) -> 0'(q1(x1))}
and weakly orienting the rules
{ q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(0(x1)) -> 0'(q1(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [1]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [7]
q4(x1) = [1] x1 + [1]
q0^#(x1) = [1] x1 + [0]
c_0(x1) = [1] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [1]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(6) -> 6
, 1_0(9) -> 6
, 1_0(10) -> 6
, b_0(6) -> 9
, b_0(9) -> 9
, b_0(10) -> 9
, q4_0(6) -> 10
, q4_0(9) -> 10
, q4_0(10) -> 10
, q0^#_0(6) -> 11
, q0^#_0(9) -> 11
, q0^#_0(10) -> 11
, 0'^#_0(6) -> 13
, 0'^#_0(9) -> 13
, 0'^#_0(10) -> 13
, q2^#_0(6) -> 20
, q2^#_0(9) -> 20
, q2^#_0(10) -> 20}
10)
{ q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, 0'^#(q1(1(x1))) -> c_4(q2^#(0'(1'(x1))))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
The usable rules for this path are the following:
{ q0(0(x1)) -> 0'(q1(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, 0'^#(q1(1(x1))) -> c_4(q2^#(0'(1'(x1))))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q1(1(x1))) -> c_4(q2^#(0'(1'(x1))))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q1(1(x1))) -> c_4(q2^#(0'(1'(x1))))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [8]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
0'^#(x1) = [1] x1 + [15]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q3(b(x1)) -> b(q4(x1))}
and weakly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q1(1(x1))) -> c_4(q2^#(0'(1'(x1))))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q3(b(x1)) -> b(q4(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [12]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [3]
0'^#(x1) = [1] x1 + [8]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0^#(0(x1)) -> c_0(0'^#(q1(x1)))}
and weakly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q1(1(x1))) -> c_4(q2^#(0'(1'(x1))))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0^#(0(x1)) -> c_0(0'^#(q1(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [1]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [9]
c_0(x1) = [1] x1 + [0]
0'^#(x1) = [1] x1 + [8]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [7]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(0(x1)) -> 0'(q1(x1))}
and weakly orienting the rules
{ q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q1(1(x1))) -> c_4(q2^#(0'(1'(x1))))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(0(x1)) -> 0'(q1(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [5]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [4]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [12]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [3]
b(x1) = [1] x1 + [1]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [9]
c_0(x1) = [1] x1 + [0]
0'^#(x1) = [1] x1 + [3]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [1]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [1]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q2(0'(x1)) -> 0'(q0(x1))}
and weakly orienting the rules
{ q0(0(x1)) -> 0'(q1(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q1(1(x1))) -> c_4(q2^#(0'(1'(x1))))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q2(0'(x1)) -> 0'(q0(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [12]
q2(x1) = [1] x1 + [10]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [15]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [9]
c_0(x1) = [1] x1 + [0]
0'^#(x1) = [1] x1 + [6]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [4]
c_4(x1) = [1] x1 + [5]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [12]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [12]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
and weakly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q1(1(x1))) -> c_4(q2^#(0'(1'(x1))))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [11]
q2(x1) = [1] x1 + [8]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [7]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [8]
c_4(x1) = [1] x1 + [2]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q1(1(x1))) -> c_4(q2^#(0'(1'(x1))))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, 0'^#(q1(1(x1))) -> c_4(q2^#(0'(1'(x1))))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(6) -> 6
, 1_0(9) -> 6
, 1_0(10) -> 6
, b_0(6) -> 9
, b_0(9) -> 9
, b_0(10) -> 9
, q4_0(6) -> 10
, q4_0(9) -> 10
, q4_0(10) -> 10
, q0^#_0(6) -> 11
, q0^#_0(9) -> 11
, q0^#_0(10) -> 11
, 0'^#_0(6) -> 13
, 0'^#_0(9) -> 13
, 0'^#_0(10) -> 13
, q2^#_0(6) -> 20
, q2^#_0(9) -> 20
, q2^#_0(10) -> 20}
11)
{ q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
The usable rules for this path are the following:
{ q0(0(x1)) -> 0'(q1(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q0(1'(x1)) -> 1'(q3(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [8]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [1] x1 + [1]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
and weakly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q3(b(x1)) -> b(q4(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [3]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [1] x1 + [1]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
and weakly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [9]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [9]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [1] x1 + [1]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))}
and weakly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q3(b(x1)) -> b(q4(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [2]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [9]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
1'^#(x1) = [1] x1 + [9]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [1] x1 + [1]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
and weakly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q3(b(x1)) -> b(q4(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [9]
q2(x1) = [1] x1 + [8]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [15]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [9]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [4]
1'^#(x1) = [1] x1 + [3]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [4]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [1] x1 + [5]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(0(x1)) -> 0'(q1(x1))}
and weakly orienting the rules
{ q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q3(b(x1)) -> b(q4(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(0(x1)) -> 0'(q1(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [4]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [7]
q4(x1) = [1] x1 + [1]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [3]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [1]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q3(b(x1)) -> b(q4(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q3(b(x1)) -> b(q4(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(6) -> 6
, 1_0(9) -> 6
, 1_0(10) -> 6
, b_0(6) -> 9
, b_0(9) -> 9
, b_0(10) -> 9
, q4_0(6) -> 10
, q4_0(9) -> 10
, q4_0(10) -> 10
, 0'^#_0(6) -> 13
, 0'^#_0(9) -> 13
, 0'^#_0(10) -> 13
, q1^#_0(6) -> 14
, q1^#_0(9) -> 14
, q1^#_0(10) -> 14
, 1'^#_0(6) -> 18
, 1'^#_0(9) -> 18
, 1'^#_0(10) -> 18
, q2^#_0(6) -> 20
, q2^#_0(9) -> 20
, q2^#_0(10) -> 20}
12)
{ q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
The usable rules for this path are the following:
{ q0(0(x1)) -> 0'(q1(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q0(1'(x1)) -> 1'(q3(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [8]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [1]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
and weakly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q3(b(x1)) -> b(q4(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [3]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [1]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
and weakly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [9]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [9]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [1]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))}
and weakly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q3(b(x1)) -> b(q4(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [15]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [9]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [3]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [1]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [15]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
and weakly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q3(b(x1)) -> b(q4(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [9]
q2(x1) = [1] x1 + [8]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [15]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [9]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [4]
1'^#(x1) = [1] x1 + [3]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [4]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [0]
c_8(x1) = [1] x1 + [5]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(0(x1)) -> 0'(q1(x1))}
and weakly orienting the rules
{ q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q3(b(x1)) -> b(q4(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(0(x1)) -> 0'(q1(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [6]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [4]
1'(x1) = [1] x1 + [8]
1(x1) = [1] x1 + [14]
q2(x1) = [1] x1 + [8]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
1'^#(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [1] x1 + [1]
c_8(x1) = [1] x1 + [1]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [1]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q3(b(x1)) -> b(q4(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, q2^#(0'(x1)) -> c_12(0'^#(q0(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q3(b(x1)) -> b(q4(x1))
, 0'^#(q2(1'(x1))) -> c_10(q2^#(0'(1'(x1))))
, 0'^#(q2(0(x1))) -> c_7(q2^#(0'(0(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(6) -> 6
, 1_0(9) -> 6
, 1_0(10) -> 6
, b_0(6) -> 9
, b_0(9) -> 9
, b_0(10) -> 9
, q4_0(6) -> 10
, q4_0(9) -> 10
, q4_0(10) -> 10
, 0'^#_0(6) -> 13
, 0'^#_0(9) -> 13
, 0'^#_0(10) -> 13
, q1^#_0(6) -> 14
, q1^#_0(9) -> 14
, q1^#_0(10) -> 14
, 1'^#_0(6) -> 18
, 1'^#_0(9) -> 18
, 1'^#_0(10) -> 18
, q2^#_0(6) -> 20
, q2^#_0(9) -> 20
, q2^#_0(10) -> 20}
13)
{ q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
The usable rules for this path are the following:
{ 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{q2(0'(x1)) -> 0'(q0(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q2(0'(x1)) -> 0'(q0(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [8]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [1] x1 + [1]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [0]
c_14(x1) = [1] x1 + [1]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(1'(x1)) -> 1'(q3(x1))}
and weakly orienting the rules
{q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(1'(x1)) -> 1'(q3(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [14]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [1] x1 + [1]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [0]
c_14(x1) = [1] x1 + [1]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))}
and weakly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [1] x1 + [1]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [0]
c_14(x1) = [1] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
and weakly orienting the rules
{ q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [3]
c_14(x1) = [1] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(0(x1)) -> 0'(q1(x1))}
and weakly orienting the rules
{ 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(0(x1)) -> 0'(q1(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [1]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [0]
c_14(x1) = [1] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q3(b(x1)) -> b(q4(x1))}
and weakly orienting the rules
{ q0(0(x1)) -> 0'(q1(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q3(b(x1)) -> b(q4(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [1]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [6]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [1] x1 + [1]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [11]
c_14(x1) = [1] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
and weakly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [14]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [14]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [1]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [0]
c_14(x1) = [1] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
Weak Rules:
{ 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
Weak Rules:
{ 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(6) -> 6
, 1_0(9) -> 6
, 1_0(10) -> 6
, b_0(6) -> 9
, b_0(9) -> 9
, b_0(10) -> 9
, q4_0(6) -> 10
, q4_0(9) -> 10
, q4_0(10) -> 10
, 1'^#_0(6) -> 18
, 1'^#_0(9) -> 18
, 1'^#_0(10) -> 18
, q2^#_0(6) -> 20
, q2^#_0(9) -> 20
, q2^#_0(10) -> 20
, q3^#_0(6) -> 31
, q3^#_0(9) -> 31
, q3^#_0(10) -> 31}
14)
{ q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
The usable rules for this path are the following:
{ 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{q2(0'(x1)) -> 0'(q0(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q2(0'(x1)) -> 0'(q0(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [8]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [1] x1 + [1]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [1]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(1'(x1)) -> 1'(q3(x1))}
and weakly orienting the rules
{q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(1'(x1)) -> 1'(q3(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [14]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [1] x1 + [1]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [1]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))}
and weakly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [1] x1 + [1]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
and weakly orienting the rules
{ q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [3]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(0(x1)) -> 0'(q1(x1))}
and weakly orienting the rules
{ 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(0(x1)) -> 0'(q1(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [1]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q3(b(x1)) -> b(q4(x1))}
and weakly orienting the rules
{ q0(0(x1)) -> 0'(q1(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q3(b(x1)) -> b(q4(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [1]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [11]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [6]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [1] x1 + [1]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
and weakly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [14]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [14]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [1]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
Weak Rules:
{ 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
Weak Rules:
{ 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(6) -> 6
, 1_0(9) -> 6
, 1_0(10) -> 6
, b_0(6) -> 9
, b_0(9) -> 9
, b_0(10) -> 9
, q4_0(6) -> 10
, q4_0(9) -> 10
, q4_0(10) -> 10
, q0^#_0(6) -> 11
, q0^#_0(9) -> 11
, q0^#_0(10) -> 11
, 1'^#_0(6) -> 18
, 1'^#_0(9) -> 18
, 1'^#_0(10) -> 18
, q2^#_0(6) -> 20
, q2^#_0(9) -> 20
, q2^#_0(10) -> 20}
15)
{ q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, 1'^#(q1(1(x1))) -> c_5(q2^#(1'(1'(x1))))}
The usable rules for this path are the following:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, 1'^#(q1(1(x1))) -> c_5(q2^#(1'(1'(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{q2(0'(x1)) -> 0'(q0(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q2(0'(x1)) -> 0'(q0(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [15]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(1'(x1)) -> 1'(q3(x1))}
and weakly orienting the rules
{q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(1'(x1)) -> 1'(q3(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [8]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{1'^#(q1(1(x1))) -> c_5(q2^#(1'(1'(x1))))}
and weakly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{1'^#(q1(1(x1))) -> c_5(q2^#(1'(1'(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [4]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
and weakly orienting the rules
{ 1'^#(q1(1(x1))) -> c_5(q2^#(1'(1'(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [4]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [9]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q3(b(x1)) -> b(q4(x1))}
and weakly orienting the rules
{ q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, 1'^#(q1(1(x1))) -> c_5(q2^#(1'(1'(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q3(b(x1)) -> b(q4(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [9]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [8]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [9]
q3(x1) = [1] x1 + [9]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
and weakly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, 1'^#(q1(1(x1))) -> c_5(q2^#(1'(1'(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [8]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [12]
1(x1) = [1] x1 + [14]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [9]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [8]
1'^#(x1) = [1] x1 + [12]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(0(x1)) -> 0'(q1(x1))}
and weakly orienting the rules
{ 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, 1'^#(q1(1(x1))) -> c_5(q2^#(1'(1'(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(0(x1)) -> 0'(q1(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [2]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [8]
q2(x1) = [1] x1 + [8]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [7]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [12]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
1'^#(x1) = [1] x1 + [8]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [1] x1 + [9]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, 1'^#(q1(1(x1))) -> c_5(q2^#(1'(1'(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, 1'^#(q1(1(x1))) -> c_5(q2^#(1'(1'(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(6) -> 6
, 1_0(9) -> 6
, 1_0(10) -> 6
, b_0(6) -> 9
, b_0(9) -> 9
, b_0(10) -> 9
, q4_0(6) -> 10
, q4_0(9) -> 10
, q4_0(10) -> 10
, q1^#_0(6) -> 14
, q1^#_0(9) -> 14
, q1^#_0(10) -> 14
, 1'^#_0(6) -> 18
, 1'^#_0(9) -> 18
, 1'^#_0(10) -> 18
, q2^#_0(6) -> 20
, q2^#_0(9) -> 20
, q2^#_0(10) -> 20}
16)
{ q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, 0^#(q1(1(x1))) -> c_3(q2^#(0(1'(x1))))}
The usable rules for this path are the following:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, 0^#(q1(1(x1))) -> c_3(q2^#(0(1'(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{q2(0'(x1)) -> 0'(q0(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q2(0'(x1)) -> 0'(q0(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [15]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [1]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(1'(x1)) -> 1'(q3(x1))}
and weakly orienting the rules
{q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(1'(x1)) -> 1'(q3(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [11]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [4]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [1]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, 0^#(q1(1(x1))) -> c_3(q2^#(0(1'(x1))))}
and weakly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q3(b(x1)) -> b(q4(x1))
, 0^#(q1(1(x1))) -> c_3(q2^#(0(1'(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [8]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [1]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q1^#(0(x1)) -> c_1(0^#(q1(x1)))}
and weakly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, 0^#(q1(1(x1))) -> c_3(q2^#(0(1'(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q1^#(0(x1)) -> c_1(0^#(q1(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [13]
c_1(x1) = [1] x1 + [10]
0^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [1]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(0(x1)) -> 0'(q1(x1))}
and weakly orienting the rules
{ q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))
, 0^#(q1(1(x1))) -> c_3(q2^#(0(1'(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(0(x1)) -> 0'(q1(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [5]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [4]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
q2^#(x1) = [1] x1 + [1]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
and weakly orienting the rules
{ q0(0(x1)) -> 0'(q1(x1))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))
, 0^#(q1(1(x1))) -> c_3(q2^#(0(1'(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [6]
0(x1) = [1] x1 + [4]
0'(x1) = [1] x1 + [10]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [8]
q2(x1) = [1] x1 + [6]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [8]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [4]
c_1(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [4]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q0(0(x1)) -> 0'(q1(x1))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))
, 0^#(q1(1(x1))) -> c_3(q2^#(0(1'(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q0(0(x1)) -> 0'(q1(x1))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))
, 0^#(q1(1(x1))) -> c_3(q2^#(0(1'(x1))))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(6) -> 6
, 1_0(9) -> 6
, 1_0(10) -> 6
, b_0(6) -> 9
, b_0(9) -> 9
, b_0(10) -> 9
, q4_0(6) -> 10
, q4_0(9) -> 10
, q4_0(10) -> 10
, q1^#_0(6) -> 14
, q1^#_0(9) -> 14
, q1^#_0(10) -> 14
, 0^#_0(6) -> 16
, 0^#_0(9) -> 16
, 0^#_0(10) -> 16
, q2^#_0(6) -> 20
, q2^#_0(9) -> 20
, q2^#_0(10) -> 20}
17)
{ q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
The usable rules for this path are the following:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(1'(x1)) -> 1'(q3(x1))}
and weakly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(1'(x1)) -> 1'(q3(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [8]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [8]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [8]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [1] x1 + [1]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q3(b(x1)) -> b(q4(x1))}
and weakly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q3(b(x1)) -> b(q4(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [7]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
1'^#(x1) = [1] x1 + [15]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [2]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [1] x1 + [1]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
and weakly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [7]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [9]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
1'^#(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [1]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
and weakly orienting the rules
{ q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [7]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [11]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
1'^#(x1) = [1] x1 + [7]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [1]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(0(x1)) -> 0'(q1(x1))}
and weakly orienting the rules
{ 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(0(x1)) -> 0'(q1(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [13]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [1]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [12]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [5]
1'^#(x1) = [1] x1 + [5]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(1'(x1))) -> c_11(q2^#(1'(1'(x1))))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(6) -> 6
, 1_0(9) -> 6
, 1_0(10) -> 6
, b_0(6) -> 9
, b_0(9) -> 9
, b_0(10) -> 9
, q4_0(6) -> 10
, q4_0(9) -> 10
, q4_0(10) -> 10
, q1^#_0(6) -> 14
, q1^#_0(9) -> 14
, q1^#_0(10) -> 14
, 1'^#_0(6) -> 18
, 1'^#_0(9) -> 18
, 1'^#_0(10) -> 18
, q2^#_0(6) -> 20
, q2^#_0(9) -> 20
, q2^#_0(10) -> 20}
18)
{ q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
The usable rules for this path are the following:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [2]
0(x1) = [1] x1 + [1]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [2]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [1]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q3(b(x1)) -> b(q4(x1))}
and weakly orienting the rules
{ q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q3(b(x1)) -> b(q4(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [8]
0(x1) = [1] x1 + [1]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
and weakly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [8]
0(x1) = [1] x1 + [1]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [1]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [8]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))}
and weakly orienting the rules
{ 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q3(b(x1)) -> b(q4(x1))
, q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q2(0'(x1)) -> 0'(q0(x1))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [8]
0(x1) = [1] x1 + [1]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [12]
q3(x1) = [1] x1 + [2]
b(x1) = [1] x1 + [3]
q4(x1) = [1] x1 + [1]
q0^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [4]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [8]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [8]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [1]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
and weakly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q3(b(x1)) -> b(q4(x1))
, q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [14]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [1]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
Weak Rules:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q3(b(x1)) -> b(q4(x1))
, q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
Weak Rules:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q3(b(x1)) -> b(q4(x1))
, q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(6) -> 6
, 1_0(9) -> 6
, 1_0(10) -> 6
, b_0(6) -> 9
, b_0(9) -> 9
, b_0(10) -> 9
, q4_0(6) -> 10
, q4_0(9) -> 10
, q4_0(10) -> 10
, q0^#_0(6) -> 11
, q0^#_0(9) -> 11
, q0^#_0(10) -> 11
, 1'^#_0(6) -> 18
, 1'^#_0(9) -> 18
, 1'^#_0(10) -> 18
, q2^#_0(6) -> 20
, q2^#_0(9) -> 20
, q2^#_0(10) -> 20}
19)
{ q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
The usable rules for this path are the following:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
and weakly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [15]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [9]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
and weakly orienting the rules
{ q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [9]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [9]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q3(b(x1)) -> b(q4(x1))}
and weakly orienting the rules
{ q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q3(b(x1)) -> b(q4(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [2]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [9]
q3(x1) = [1] x1 + [2]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [9]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
1'^#(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [2]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
and weakly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [12]
1(x1) = [1] x1 + [15]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
1'^#(x1) = [1] x1 + [12]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(6) -> 6
, 1_0(9) -> 6
, 1_0(10) -> 6
, b_0(6) -> 9
, b_0(9) -> 9
, b_0(10) -> 9
, q4_0(6) -> 10
, q4_0(9) -> 10
, q4_0(10) -> 10
, q1^#_0(6) -> 14
, q1^#_0(9) -> 14
, q1^#_0(10) -> 14
, 1'^#_0(6) -> 18
, 1'^#_0(9) -> 18
, 1'^#_0(10) -> 18
, q2^#_0(6) -> 20
, q2^#_0(9) -> 20
, q2^#_0(10) -> 20}
20)
{ q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, 0^#(q2(1'(x1))) -> c_9(q2^#(0(1'(x1))))}
The usable rules for this path are the following:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, 0^#(q2(1'(x1))) -> c_9(q2^#(0(1'(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(1'(x1))) -> c_9(q2^#(0(1'(x1))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(1'(x1))) -> c_9(q2^#(0(1'(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q1^#(0(x1)) -> c_1(0^#(q1(x1)))}
and weakly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(1'(x1))) -> c_9(q2^#(0(1'(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q1^#(0(x1)) -> c_1(0^#(q1(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [15]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [9]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
and weakly orienting the rules
{ q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(1'(x1))) -> c_9(q2^#(0(1'(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [9]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [9]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q3(b(x1)) -> b(q4(x1))}
and weakly orienting the rules
{ q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(1'(x1))) -> c_9(q2^#(0(1'(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q3(b(x1)) -> b(q4(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [2]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [9]
q3(x1) = [1] x1 + [2]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [9]
c_1(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [2]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
and weakly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(1'(x1))) -> c_9(q2^#(0(1'(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [2]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [15]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [4]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(1'(x1))) -> c_9(q2^#(0(1'(x1))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(1'(x1))) -> c_9(q2^#(0(1'(x1))))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(6) -> 6
, 1_0(9) -> 6
, 1_0(10) -> 6
, b_0(6) -> 9
, b_0(9) -> 9
, b_0(10) -> 9
, q4_0(6) -> 10
, q4_0(9) -> 10
, q4_0(10) -> 10
, q1^#_0(6) -> 14
, q1^#_0(9) -> 14
, q1^#_0(10) -> 14
, 0^#_0(6) -> 16
, 0^#_0(9) -> 16
, 0^#_0(10) -> 16
, q2^#_0(6) -> 20
, q2^#_0(9) -> 20
, q2^#_0(10) -> 20}
21)
{ q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, 0'^#(q1(1(x1))) -> c_4(q2^#(0'(1'(x1))))}
The usable rules for this path are the following:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, 0'^#(q1(1(x1))) -> c_4(q2^#(0'(1'(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{q2(0'(x1)) -> 0'(q0(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q2(0'(x1)) -> 0'(q0(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [1] x1 + [1]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, 0'^#(q1(1(x1))) -> c_4(q2^#(0'(1'(x1))))}
and weakly orienting the rules
{q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q0(1'(x1)) -> 1'(q3(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, 0'^#(q1(1(x1))) -> c_4(q2^#(0'(1'(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [4]
c_0(x1) = [1] x1 + [1]
0'^#(x1) = [1] x1 + [1]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [1] x1 + [1]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))}
and weakly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, 0'^#(q1(1(x1))) -> c_4(q2^#(0'(1'(x1))))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [7]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [1]
q0^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(0(x1)) -> 0'(q1(x1))}
and weakly orienting the rules
{ 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, 0'^#(q1(1(x1))) -> c_4(q2^#(0'(1'(x1))))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(0(x1)) -> 0'(q1(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [2]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [8]
q2(x1) = [1] x1 + [8]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [9]
c_0(x1) = [1] x1 + [4]
0'^#(x1) = [1] x1 + [4]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [1] x1 + [1]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q3(b(x1)) -> b(q4(x1))}
and weakly orienting the rules
{ q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, 0'^#(q1(1(x1))) -> c_4(q2^#(0'(1'(x1))))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q3(b(x1)) -> b(q4(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [7]
0(x1) = [1] x1 + [2]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [9]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [7]
q2(x1) = [1] x1 + [8]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [4]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [15]
c_0(x1) = [1] x1 + [0]
0'^#(x1) = [1] x1 + [8]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q3(b(x1)) -> b(q4(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, 0'^#(q1(1(x1))) -> c_4(q2^#(0'(1'(x1))))
, q2(0'(x1)) -> 0'(q0(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q3(b(x1)) -> b(q4(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, 0'^#(q1(1(x1))) -> c_4(q2^#(0'(1'(x1))))
, q2(0'(x1)) -> 0'(q0(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(6) -> 6
, 1_0(9) -> 6
, 1_0(10) -> 6
, b_0(6) -> 9
, b_0(9) -> 9
, b_0(10) -> 9
, q4_0(6) -> 10
, q4_0(9) -> 10
, q4_0(10) -> 10
, q0^#_0(6) -> 11
, q0^#_0(9) -> 11
, q0^#_0(10) -> 11
, 0'^#_0(6) -> 13
, 0'^#_0(9) -> 13
, 0'^#_0(10) -> 13
, q2^#_0(6) -> 20
, q2^#_0(9) -> 20
, q2^#_0(10) -> 20}
22)
{ q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
The usable rules for this path are the following:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [2]
0(x1) = [1] x1 + [1]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [2]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [1]
c_14(x1) = [1] x1 + [1]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q3(b(x1)) -> b(q4(x1))}
and weakly orienting the rules
{ q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q3(b(x1)) -> b(q4(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [8]
0(x1) = [1] x1 + [1]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [1]
c_14(x1) = [1] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
and weakly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [8]
0(x1) = [1] x1 + [1]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [1]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [8]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [1]
c_14(x1) = [1] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))}
and weakly orienting the rules
{ 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q3(b(x1)) -> b(q4(x1))
, q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q2(0'(x1)) -> 0'(q0(x1))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [8]
0(x1) = [1] x1 + [1]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [12]
q3(x1) = [1] x1 + [2]
b(x1) = [1] x1 + [3]
q4(x1) = [1] x1 + [1]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [4]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [8]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [8]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [9]
c_14(x1) = [1] x1 + [1]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
and weakly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q3(b(x1)) -> b(q4(x1))
, q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [14]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [1]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [0]
c_14(x1) = [1] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
Weak Rules:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q3(b(x1)) -> b(q4(x1))
, q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
Weak Rules:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, 1'^#(q2(0(x1))) -> c_8(q2^#(1'(0(x1))))
, q3(b(x1)) -> b(q4(x1))
, q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(6) -> 6
, 1_0(9) -> 6
, 1_0(10) -> 6
, b_0(6) -> 9
, b_0(9) -> 9
, b_0(10) -> 9
, q4_0(6) -> 10
, q4_0(9) -> 10
, q4_0(10) -> 10
, 1'^#_0(6) -> 18
, 1'^#_0(9) -> 18
, 1'^#_0(10) -> 18
, q2^#_0(6) -> 20
, q2^#_0(9) -> 20
, q2^#_0(10) -> 20
, q3^#_0(6) -> 31
, q3^#_0(9) -> 31
, q3^#_0(10) -> 31}
23)
{ q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, 0^#(q2(0(x1))) -> c_6(q2^#(0(0(x1))))}
The usable rules for this path are the following:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, 0^#(q2(0(x1))) -> c_6(q2^#(0(0(x1))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(0(x1))) -> c_6(q2^#(0(0(x1))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(0(x1))) -> c_6(q2^#(0(0(x1))))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q1^#(0(x1)) -> c_1(0^#(q1(x1)))}
and weakly orienting the rules
{ q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(0(x1))) -> c_6(q2^#(0(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q1^#(0(x1)) -> c_1(0^#(q1(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [7]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [9]
c_1(x1) = [1] x1 + [3]
0^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))}
and weakly orienting the rules
{ q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(0(x1))) -> c_6(q2^#(0(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [7]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [1]
1(x1) = [1] x1 + [12]
q2(x1) = [1] x1 + [9]
q3(x1) = [1] x1 + [10]
b(x1) = [1] x1 + [8]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [9]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [1]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(1'(x1)) -> 1'(q3(x1))}
and weakly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(0(x1))) -> c_6(q2^#(0(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(1'(x1)) -> 1'(q3(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [2]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [7]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [9]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [8]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [6]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(0(x1)) -> 0'(q1(x1))}
and weakly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(0(x1))) -> c_6(q2^#(0(0(x1))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(0(x1)) -> 0'(q1(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [8]
q2(x1) = [1] x1 + [8]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [15]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [13]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [7]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [1] x1 + [9]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [2]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(0(x1))) -> c_6(q2^#(0(0(x1))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, q0(1'(x1)) -> 1'(q3(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, 0^#(q2(0(x1))) -> c_6(q2^#(0(0(x1))))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(6) -> 6
, 1_0(9) -> 6
, 1_0(10) -> 6
, b_0(6) -> 9
, b_0(9) -> 9
, b_0(10) -> 9
, q4_0(6) -> 10
, q4_0(9) -> 10
, q4_0(10) -> 10
, q1^#_0(6) -> 14
, q1^#_0(9) -> 14
, q1^#_0(10) -> 14
, 0^#_0(6) -> 16
, 0^#_0(9) -> 16
, 0^#_0(10) -> 16
, q2^#_0(6) -> 20
, q2^#_0(9) -> 20
, q2^#_0(10) -> 20}
24)
{q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))}
The usable rules for this path are the following:
{ q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))}
and weakly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(0(x1)) -> 0'(q1(x1))}
and weakly orienting the rules
{ q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(0(x1)) -> 0'(q1(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [8]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
and weakly orienting the rules
{ q0(0(x1)) -> 0'(q1(x1))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [2]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [8]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [1]
q0^#(x1) = [1] x1 + [12]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [9]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [1]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(1'(x1)) -> 1'(q3(x1))}
and weakly orienting the rules
{ 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q0(0(x1)) -> 0'(q1(x1))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(1'(x1)) -> 1'(q3(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [4]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [8]
q2(x1) = [1] x1 + [8]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [1] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q3(1'(x1)) -> 1'(q3(x1))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
Weak Rules:
{ q0(1'(x1)) -> 1'(q3(x1))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q0(0(x1)) -> 0'(q1(x1))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q3(1'(x1)) -> 1'(q3(x1))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
Weak Rules:
{ q0(1'(x1)) -> 1'(q3(x1))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q0(0(x1)) -> 0'(q1(x1))
, q0^#(1'(x1)) -> c_13(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(6) -> 6
, 1_0(9) -> 6
, 1_0(10) -> 6
, b_0(6) -> 9
, b_0(9) -> 9
, b_0(10) -> 9
, q4_0(6) -> 10
, q4_0(9) -> 10
, q4_0(10) -> 10
, q0^#_0(6) -> 11
, q0^#_0(9) -> 11
, q0^#_0(10) -> 11
, 1'^#_0(6) -> 18
, 1'^#_0(9) -> 18
, 1'^#_0(10) -> 18}
25)
{q0^#(0(x1)) -> c_0(0'^#(q1(x1)))}
The usable rules for this path are the following:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{q2(0'(x1)) -> 0'(q0(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q2(0'(x1)) -> 0'(q0(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [8]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(1'(x1)) -> 1'(q3(x1))}
and weakly orienting the rules
{q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(1'(x1)) -> 1'(q3(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))}
and weakly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q3(b(x1)) -> b(q4(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [5]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [1]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [13]
c_0(x1) = [1] x1 + [0]
0'^#(x1) = [1] x1 + [8]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
and weakly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [8]
1(x1) = [1] x1 + [13]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [11]
c_0(x1) = [1] x1 + [1]
0'^#(x1) = [1] x1 + [1]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(0(x1)) -> 0'(q1(x1))}
and weakly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(0(x1)) -> 0'(q1(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [2]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [2]
q2(x1) = [1] x1 + [2]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [3]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
0'^#(x1) = [1] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))
, q0^#(0(x1)) -> c_0(0'^#(q1(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(6) -> 6
, 1_0(9) -> 6
, 1_0(10) -> 6
, b_0(6) -> 9
, b_0(9) -> 9
, b_0(10) -> 9
, q4_0(6) -> 10
, q4_0(9) -> 10
, q4_0(10) -> 10
, q0^#_0(6) -> 11
, q0^#_0(9) -> 11
, q0^#_0(10) -> 11
, 0'^#_0(6) -> 13
, 0'^#_0(9) -> 13
, 0'^#_0(10) -> 13}
26)
{q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
The usable rules for this path are the following:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{q2(0'(x1)) -> 0'(q0(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q2(0'(x1)) -> 0'(q0(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [8]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(1'(x1)) -> 1'(q3(x1))}
and weakly orienting the rules
{q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(1'(x1)) -> 1'(q3(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [4]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
and weakly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q3(b(x1)) -> b(q4(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [9]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
and weakly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [2]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [4]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [12]
q2(x1) = [1] x1 + [12]
q3(x1) = [1] x1 + [2]
b(x1) = [1] x1 + [15]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [5]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
1'^#(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(0(x1)) -> 0'(q1(x1))}
and weakly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(0(x1)) -> 0'(q1(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [2]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [6]
q2(x1) = [1] x1 + [2]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [4]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [1] x1 + [1]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))
, q1^#(1'(x1)) -> c_2(1'^#(q1(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(6) -> 6
, 1_0(9) -> 6
, 1_0(10) -> 6
, b_0(6) -> 9
, b_0(9) -> 9
, b_0(10) -> 9
, q4_0(6) -> 10
, q4_0(9) -> 10
, q4_0(10) -> 10
, q1^#_0(6) -> 14
, q1^#_0(9) -> 14
, q1^#_0(10) -> 14
, 1'^#_0(6) -> 18
, 1'^#_0(9) -> 18
, 1'^#_0(10) -> 18}
27)
{q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))}
The usable rules for this path are the following:
{ q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [1]
c_14(x1) = [1] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))}
and weakly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [1]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [9]
c_14(x1) = [1] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(0(x1)) -> 0'(q1(x1))}
and weakly orienting the rules
{ q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(0(x1)) -> 0'(q1(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [8]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [9]
c_14(x1) = [1] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
and weakly orienting the rules
{ q0(0(x1)) -> 0'(q1(x1))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [2]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [0]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [8]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [1]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [9]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [12]
c_14(x1) = [1] x1 + [1]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(1'(x1)) -> 1'(q3(x1))}
and weakly orienting the rules
{ 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q0(0(x1)) -> 0'(q1(x1))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(1'(x1)) -> 1'(q3(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [4]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [8]
q2(x1) = [1] x1 + [8]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [9]
c_14(x1) = [1] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q3(1'(x1)) -> 1'(q3(x1))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
Weak Rules:
{ q0(1'(x1)) -> 1'(q3(x1))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q0(0(x1)) -> 0'(q1(x1))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q3(1'(x1)) -> 1'(q3(x1))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))}
Weak Rules:
{ q0(1'(x1)) -> 1'(q3(x1))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q0(0(x1)) -> 0'(q1(x1))
, q3^#(1'(x1)) -> c_14(1'^#(q3(x1)))
, q3(b(x1)) -> b(q4(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(6) -> 6
, 1_0(9) -> 6
, 1_0(10) -> 6
, b_0(6) -> 9
, b_0(9) -> 9
, b_0(10) -> 9
, q4_0(6) -> 10
, q4_0(9) -> 10
, q4_0(10) -> 10
, 1'^#_0(6) -> 18
, 1'^#_0(9) -> 18
, 1'^#_0(10) -> 18
, q3^#_0(6) -> 31
, q3^#_0(9) -> 31
, q3^#_0(10) -> 31}
28)
{q1^#(0(x1)) -> c_1(0^#(q1(x1)))}
The usable rules for this path are the following:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, q2(0'(x1)) -> 0'(q0(x1))
, q0(0(x1)) -> 0'(q1(x1))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q3(1'(x1)) -> 1'(q3(x1))
, q3(b(x1)) -> b(q4(x1))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{q2(0'(x1)) -> 0'(q0(x1))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q2(0'(x1)) -> 0'(q0(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [8]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(1'(x1)) -> 1'(q3(x1))}
and weakly orienting the rules
{q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(1'(x1)) -> 1'(q3(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))}
and weakly orienting the rules
{ q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ q3(b(x1)) -> b(q4(x1))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [5]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [0]
q2(x1) = [1] x1 + [1]
q3(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [1]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [13]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [8]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
and weakly orienting the rules
{ q3(b(x1)) -> b(q4(x1))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [0]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [8]
1(x1) = [1] x1 + [13]
q2(x1) = [1] x1 + [0]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [11]
c_1(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{q0(0(x1)) -> 0'(q1(x1))}
and weakly orienting the rules
{ 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q0(0(x1)) -> 0'(q1(x1))}
Details:
Interpretation Functions:
q0(x1) = [1] x1 + [2]
0(x1) = [1] x1 + [0]
0'(x1) = [1] x1 + [0]
q1(x1) = [1] x1 + [1]
1'(x1) = [1] x1 + [0]
1(x1) = [1] x1 + [2]
q2(x1) = [1] x1 + [2]
q3(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [3]
q4(x1) = [1] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ q1(0(x1)) -> 0(q1(x1))
, q1(1'(x1)) -> 1'(q1(x1))
, 0(q2(0(x1))) -> q2(0(0(x1)))
, 1'(q2(0(x1))) -> q2(1'(0(x1)))
, 0(q2(1'(x1))) -> q2(0(1'(x1)))
, 1'(q2(1'(x1))) -> q2(1'(1'(x1)))
, 0'(q2(0(x1))) -> q2(0'(0(x1)))
, 0'(q2(1'(x1))) -> q2(0'(1'(x1)))
, q3(1'(x1)) -> 1'(q3(x1))}
Weak Rules:
{ q0(0(x1)) -> 0'(q1(x1))
, 0(q1(1(x1))) -> q2(0(1'(x1)))
, 1'(q1(1(x1))) -> q2(1'(1'(x1)))
, 0'(q1(1(x1))) -> q2(0'(1'(x1)))
, q3(b(x1)) -> b(q4(x1))
, q1^#(0(x1)) -> c_1(0^#(q1(x1)))
, q0(1'(x1)) -> 1'(q3(x1))
, q2(0'(x1)) -> 0'(q0(x1))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ 1_0(6) -> 6
, 1_0(9) -> 6
, 1_0(10) -> 6
, b_0(6) -> 9
, b_0(9) -> 9
, b_0(10) -> 9
, q4_0(6) -> 10
, q4_0(9) -> 10
, q4_0(10) -> 10
, q1^#_0(6) -> 14
, q1^#_0(9) -> 14
, q1^#_0(10) -> 14
, 0^#_0(6) -> 16
, 0^#_0(9) -> 16
, 0^#_0(10) -> 16}
29)
{q3^#(b(x1)) -> c_15()}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
q0(x1) = [0] x1 + [0]
0(x1) = [0] x1 + [0]
0'(x1) = [0] x1 + [0]
q1(x1) = [0] x1 + [0]
1'(x1) = [0] x1 + [0]
1(x1) = [0] x1 + [0]
q2(x1) = [0] x1 + [0]
q3(x1) = [0] x1 + [0]
b(x1) = [0] x1 + [0]
q4(x1) = [0] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [0] x1 + [0]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {q3^#(b(x1)) -> c_15()}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{q3^#(b(x1)) -> c_15()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{q3^#(b(x1)) -> c_15()}
Details:
Interpretation Functions:
q0(x1) = [0] x1 + [0]
0(x1) = [0] x1 + [0]
0'(x1) = [0] x1 + [0]
q1(x1) = [0] x1 + [0]
1'(x1) = [0] x1 + [0]
1(x1) = [0] x1 + [0]
q2(x1) = [0] x1 + [0]
q3(x1) = [0] x1 + [0]
b(x1) = [1] x1 + [0]
q4(x1) = [0] x1 + [0]
q0^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
0'^#(x1) = [0] x1 + [0]
q1^#(x1) = [0] x1 + [0]
c_1(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
1'^#(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
q2^#(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
c_13(x1) = [0] x1 + [0]
q3^#(x1) = [1] x1 + [1]
c_14(x1) = [0] x1 + [0]
c_15() = [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {q3^#(b(x1)) -> c_15()}
Details:
The given problem does not contain any strict rules